import { defineStore } from 'pinia'
import DatabaseService from '../services/database'

export const useTableStructureStore = defineStore('tableStructure', {
  state: () => ({
    // 当前表结构
    structure: null,
    
    // 加载状态
    isLoading: false,
    
    // 错误信息
    error: null,
    
    // 缓存
    structureCache: new Map() // key: `${configId}:${database}:${table}`, value: structure
  }),
  
  getters: {
    // 获取表结构
    getStructure: (state) => {
      return state.structure
    },
    
    // 获取缓存的表结构
    getCachedStructure: (state) => (configId, database, table) => {
      const key = `${configId}:${database}:${table}`
      return state.structureCache.get(key)
    }
  },
  
  actions: {
    // 获取表结构 - 从多个API调用中合成表结构
    async fetchTableStructure({ configId, database, table, databaseType }) {
      // 校验必要参数
      if (!configId || !database || !table) {
        console.error('Missing required parameters:', { configId, database, table });
        throw new Error('Missing required parameters for fetching table structure');
      }
      
      const key = `${configId}:${database}:${table}`;
      
      // 日志
      console.log('Fetching table structure with:', { key, configId, database, table, databaseType });
      
      // 检查缓存
      const cached = this.structureCache.get(key);
      if (cached) {
        this.structure = cached;
        return cached;
      }
      
      this.isLoading = true;
      this.error = null;
      
      try {
        // 首先验证连接是否存在和有效
        try {
          // 获取所有配置以验证configId是否有效
          const configs = await DatabaseService.getAllConfigs();
          const configExists = configs.some(c => c.id === configId);
          
          if (!configExists) {
            throw new Error(`Connection configuration with ID ${configId} does not exist`);
          }
        } catch (err) {
          console.error('Failed to validate connection config:', err);
          throw new Error(`Unable to validate connection: ${err.message}`);
        }
        
        // 创建表结构对象
        const structure = {
          name: table,
          databaseType: databaseType || 'mysql', // 默认为MySQL
          columns: [],
          indexes: [],
          foreignKeys: [],
          advancedOptions: {}
        };
        
        // 获取表信息
        console.log('Getting table info for:', database, table);
        try {
          const tables = await DatabaseService.listTables(configId, database);
          const tableInfo = tables.find(t => t.name === table || t.Name === table);
          
          if (tableInfo) {
            structure.engine = tableInfo.engine || tableInfo.Engine;
            if (tableInfo.collation || tableInfo.Collation) {
              const collation = tableInfo.collation || tableInfo.Collation;
              structure.charset = collation?.split('_')[0];
              structure.collation = collation;
            }
            structure.comment = tableInfo.comment || tableInfo.Comment;
          } else {
            console.warn(`Table ${table} not found in database ${database}`);
          }
        } catch (err) {
          console.error('Failed to get table info:', err);
        }
        
        // 获取列信息
        console.log('Getting columns for:', database, table);
        try {
          const columnsData = await DatabaseService.getTableColumns(configId, database, table);
          
          // 确保所有字段都有一致的属性名（无论后端返回的是驼峰命名还是下划线命名）
          structure.columns = columnsData.map(col => {
            // 创建一个标准化的列对象
            return {
              name: col.name || col.Name,
              type: col.type || col.Type,
              fullType: col.full_type || col.fullType || col.FullType || col.type || col.Type,
              length: col.length || col.Length || 0,
              precision: col.precision || col.Precision || 0,
              scale: col.scale || col.Scale || 0,
              
              // NULL属性 (支持多种可能的字段名)
              isNullable: col.is_nullable ?? col.isNullable ?? col.IsNullable ?? !col.not_null ?? !col.notNull ?? !col.NotNull ?? true,
              notNull: col.not_null ?? col.notNull ?? col.NotNull ?? !col.is_nullable ?? !col.isNullable ?? !col.IsNullable ?? false,
              
              // 主键属性
              isPrimaryKey: col.is_primary_key ?? col.isPrimaryKey ?? col.IsPrimaryKey ?? col.primary_key ?? col.primaryKey ?? col.PrimaryKey ?? false,
              primaryKey: col.primary_key ?? col.primaryKey ?? col.PrimaryKey ?? col.is_primary_key ?? col.isPrimaryKey ?? col.IsPrimaryKey ?? false,
              
              // 自增属性
              isAutoIncrement: col.is_auto_increment ?? col.isAutoIncrement ?? col.IsAutoIncrement ?? col.auto_increment ?? col.autoIncrement ?? col.AutoIncrement ?? false,
              autoIncrement: col.auto_increment ?? col.autoIncrement ?? col.AutoIncrement ?? col.is_auto_increment ?? col.isAutoIncrement ?? col.IsAutoIncrement ?? false,
              
              // 其他属性
              defaultValue: col.default_value ?? col.defaultValue ?? col.DefaultValue ?? '',
              comment: col.comment ?? col.Comment ?? '',
              position: col.position ?? col.Position ?? 0,
              charset: col.charset ?? col.Charset ?? '',
              collation: col.collation ?? col.Collation ?? '',
              extra: col.extra ?? col.Extra ?? '',
              
              // 枚举/集合值
              values: col.values ?? col.Values ?? [],
              
              // 原始信息
              rawInfo: col.raw_info ?? col.rawInfo ?? col.RawInfo ?? {}
            };
          });
          
          // 确保主键列被标记
          const primaryKeyCol = structure.columns.find(col => col.primaryKey || col.isPrimaryKey);
          if (primaryKeyCol) {
            structure.primaryKey = primaryKeyCol.name;
          }
        } catch (err) {
          console.error('Failed to get table columns:', err);
          structure.columns = [];
        }
        
        // 获取索引信息
        console.log('Getting indexes for:', database, table);
        try {
          structure.indexes = await DatabaseService.getTableIndexes(configId, database, table);
        } catch (err) {
          console.error('Failed to get table indexes:', err);
          structure.indexes = [];
        }
        
        // 尝试获取外键信息（如果API支持）
        try {
          if (DatabaseService.getTableForeignKeys) {
            structure.foreignKeys = await DatabaseService.getTableForeignKeys(configId, database, table);
          }
        } catch (err) {
          console.warn('Failed to get foreign keys, maybe not supported:', err);
          structure.foreignKeys = [];
        }
        
        console.log('Table structure data:', structure);
        
        // 更新状态和缓存
        this.structure = structure;
        this.structureCache.set(key, structure);
        
        return structure;
      } catch (error) {
        this.error = error.message || 'Failed to fetch table structure';
        console.error('Failed to fetch table structure:', error);
        throw error;
      } finally {
        this.isLoading = false;
      }
    },
    
    // 验证结构更改是否安全
    async validateStructureChange({ configId, database, table, structure, originalStructure, isNewTable, databaseType }) {
      // 新表不需要验证
      if (isNewTable) {
        return { safe: true, warnings: [], errors: [] };
      }
      
      const validationResults = { safe: true, warnings: [], errors: [] };
      
      try {
        // 检查非空约束
        for (const col of structure.columns) {
          if (col.notNull) {
            // 找到原结构中的对应列
            const originalCol = originalStructure?.columns?.find(c => c.name === col.name);
            
            // 如果是新增列或原列允许NULL，需要检查
            if (!originalCol || !originalCol.notNull) {
              if (!col.defaultValue) {
                // 检查表中是否有NULL值
                try {
                  // 使用COUNT查询检测NULL值
                  const result = await DatabaseService.executeQuery(
                    configId,
                    `SELECT COUNT(*) as nullCount FROM ${database}.${table} WHERE ${col.name} IS NULL`
                  );
                  
                  const nullCount = result?.[0]?.nullCount || 0;
                  if (nullCount > 0) {
                    validationResults.safe = false;
                    validationResults.warnings.push({
                      type: 'NOT_NULL_CONSTRAINT',
                      column: col.name,
                      message: `列 ${col.name} 设置为非空将失败：表中有 ${nullCount} 行包含NULL值`,
                      suggestion: '添加默认值或先更新现有数据'
                    });
                  }
                } catch (err) {
                  console.warn(`无法验证列 ${col.name} 的NULL值:`, err);
                }
              }
            }
          }
        }
        
        // 检查类型兼容性
        for (const col of structure.columns) {
          const originalCol = originalStructure?.columns?.find(c => c.name === col.name);
          if (originalCol && col.type !== originalCol.type) {
            // 类型转换可能有风险的情况
            const riskyCombinations = [
              { from: 'int', to: 'varchar', risk: '数值可能被截断或格式化丢失' },
              { from: 'datetime', to: 'varchar', risk: '日期格式可能丢失' },
              { from: 'varchar', to: 'int', risk: '非数值字符串将导致转换失败' },
              { from: 'varchar', to: 'datetime', risk: '格式无效的字符串将导致转换失败' }
            ];
            
            const riskyChange = riskyCombinations.find(
              r => originalCol.type.toLowerCase().includes(r.from) && col.type.toLowerCase().includes(r.to)
            );
            
            if (riskyChange) {
              validationResults.warnings.push({
                type: 'TYPE_CONVERSION',
                column: col.name,
                message: `列 ${col.name} 从 ${originalCol.type} 转换为 ${col.type} 可能有风险`,
                suggestion: `${riskyChange.risk}，请先确保数据兼容`
              });
            }
          }
        }
        
        // 添加数据库特定的验证逻辑
        switch (databaseType) {
          case 'mysql':
            // MySQL特定验证...
            break;
          case 'postgresql':
            // PostgreSQL特定验证...
            break;
          // 其他数据库类型...
        }
        
      } catch (error) {
        console.error('结构验证失败:', error);
        validationResults.safe = false;
        validationResults.errors.push({
          type: 'VALIDATION_FAILED',
          message: `验证过程失败: ${error.message}`
        });
      }
      
      return validationResults;
    },
    
    // 保存表结构
    async saveTableStructure({ configId, database, table, structure, isNewTable, databaseType, originalStructure }) {
      if (!structure) {
        throw new Error('结构不能为空')
      }
      
      this.isLoading = true
      
      try {
        // 新增：在保存前进行验证
        if (!isNewTable && originalStructure) {
          const validationResults = await this.validateStructureChange({
            configId, 
            database, 
            table, 
            structure, 
            originalStructure, 
            isNewTable, 
            databaseType
          });
          
          // 如果有验证问题，返回而不执行保存
          if (!validationResults.safe && validationResults.warnings.length > 0) {
            return { 
              success: false, 
              validated: true,
              validationResults
            };
          }
        }
        
        // 创建新表或修改现有表
        if (isNewTable) {
          // 生成创建表SQL
          const createSQL = this.generateCreateSQL(structure)
          
          // 执行SQL
          try {
            await DatabaseService.ExecuteBatchSQL(configId, [createSQL])
          } catch (error) {
            console.error('Failed to create table:', error)
            
            // 解析错误信息，但保留原始错误
            const errorDetails = this.parseErrorMessage(error.message, databaseType);
            
            // 直接抛出原始错误消息
            throw new Error(`表创建失败: ${error.message}`);
          }
        } else {
          // 获取当前表结构（如果未提供）
          let currentStructure = originalStructure
          if (!currentStructure) {
            try {
              currentStructure = await this.fetchTableStructure({ configId, database, table, databaseType })
            } catch (error) {
              console.warn('Failed to fetch original structure:', error)
            }
          }
          
          // 构建修改结构
          const alterSchema = this.buildAlterSchema(structure, currentStructure)
          
          // 检查是否有变更
          if (!this.hasChanges(alterSchema)) {
            console.log('No changes detected, skipping table alteration')
            return { success: true, message: 'No changes detected' }
          }
          
          console.log('Altering table with schema:', alterSchema)
          
          // 修复：不使用事务，直接执行SQL
          try {
            // 尝试使用 AlterTable 方法（如果可用）
            try {
              if (typeof DatabaseService.AlterTable === 'function') {
                const result = await DatabaseService.AlterTable(configId, database, table, alterSchema)
                console.log('Table alteration result:', result)
              } else {
                // 替代方案：生成并执行 ALTER TABLE SQL
                const alterSQL = this.generateAlterSQL(structure, currentStructure)
                if (alterSQL && alterSQL.length > 0) {
                  // 分批执行多条SQL语句
                  const sqlStatements = alterSQL.split(';').filter(sql => sql.trim() !== '');
                  // 使用ExecuteBatchSQL执行批量SQL
                  await DatabaseService.ExecuteBatchSQL(configId, sqlStatements.map(sql => `${sql};`));
                } else {
                  throw new Error('无法生成修改表SQL')
                }
              }
            } catch (error) {
              console.error('Failed to save table structure:', error)
              
              // 解析错误信息，但保留原始错误
              const errorDetails = this.parseErrorMessage(error.message, databaseType);
              
              // 直接抛出原始错误消息
              throw new Error(error.message);
            }
          } catch (error) {
            throw error; // 重新抛出解析后的错误
          }
        }
        
        // 强制清除所有相关缓存，确保任何时候都获取最新数据
        this.clearAllTableStructureCaches(configId, database)
        
        // 记录日志
        console.log(`Table structure saved successfully for ${database}.${structure.name}`)
        return { success: true }
      } catch (error) {
        this.error = error.message || 'Failed to save table structure'
        console.error('Failed to save table structure:', error)
        throw error
      } finally {
        this.isLoading = false
      }
    },
    
    // 解析数据库错误信息，提供更友好的提示
    parseErrorMessage(errorMessage, databaseType) {
      const result = {
        originalMessage: errorMessage,
        userMessage: errorMessage, // 默认使用原始错误消息
        errorCode: null,
        errorType: 'UNKNOWN',
        additionalInfo: null // 添加额外提示信息，但不替换原始错误
      };
      
      // 检测常见问题并添加额外信息
      if (errorMessage.toLowerCase().includes('cannot be null') || 
          errorMessage.toLowerCase().includes('not null') || 
          errorMessage.toLowerCase().includes('null值')) {
        result.errorType = 'NOT_NULL_CONSTRAINT';
        result.additionalInfo = '提示：表中已有NULL值。请先设置默认值或更新数据。';
      } else if (errorMessage.toLowerCase().includes('duplicate') || 
                errorMessage.toLowerCase().includes('unique') || 
                errorMessage.toLowerCase().includes('唯一')) {
        result.errorType = 'UNIQUE_CONSTRAINT';
        result.additionalInfo = '提示：表中已有重复值。请先修复重复数据。';
      } else if (errorMessage.toLowerCase().includes('data') && 
                errorMessage.toLowerCase().includes('truncated')) {
        result.errorType = 'DATA_TRUNCATION';
        result.additionalInfo = '提示：可能是减小了字段长度，但现有数据超出新长度。';
      } else if (errorMessage.toLowerCase().includes('foreign key')) {
        result.errorType = 'FOREIGN_KEY_CONSTRAINT';
        result.additionalInfo = '提示：请确保引用的表和列存在且兼容。';
      }
      
      // 根据数据库类型提取错误代码
      if (databaseType === 'mysql') {
        const codeMatch = errorMessage.match(/ERROR (\d+):/i) || errorMessage.match(/Error (\d+)/i);
        if (codeMatch) {
          result.errorCode = codeMatch[1];
        }
      }
      
      return result;
    },
    
    // 构建表修改结构
    buildAlterSchema(newStructure, currentStructure) {
      const alterSchema = {
        addColumns: [],
        modifyColumns: [],
        dropColumns: [],
        renameColumns: {},
        addIndexes: [],
        dropIndexes: [],
        addForeignKeys: [],
        dropForeignKeys: []
      };
      
      if (!currentStructure) {
        // 如果没有当前结构，将所有列视为修改
        alterSchema.modifyColumns = newStructure.columns.map(this.normalizeColumnSchema);
        alterSchema.addIndexes = newStructure.indexes || [];
        alterSchema.addForeignKeys = newStructure.foreignKeys || [];
      } else {
        // 比较列
        const currentColumnMap = new Map();
        currentStructure.columns.forEach(col => {
          currentColumnMap.set(col.name, col);
        });
        
        const newColumnMap = new Map();
        newStructure.columns.forEach(col => {
          newColumnMap.set(col.name, col);
        });
        
        // 查找新增的列
        newStructure.columns.forEach(col => {
          if (!currentColumnMap.has(col.name)) {
            alterSchema.addColumns.push(this.normalizeColumnSchema(col));
          } else {
            // 检查列是否有修改
            const currentCol = currentColumnMap.get(col.name);
            if (this.isColumnChanged(col, currentCol)) {
              alterSchema.modifyColumns.push(this.normalizeColumnSchema(col));
            }
          }
        });
        
        // 查找删除的列
        currentStructure.columns.forEach(col => {
          if (!newColumnMap.has(col.name)) {
            alterSchema.dropColumns.push(col.name);
          }
        });
        
        // 比较索引
        const currentIndexMap = new Map();
        (currentStructure.indexes || []).forEach(idx => {
          currentIndexMap.set(idx.name, idx);
        });
        
        const newIndexMap = new Map();
        (newStructure.indexes || []).forEach(idx => {
          newIndexMap.set(idx.name, idx);
        });
        
        // 查找新增的索引
        (newStructure.indexes || []).forEach(idx => {
          if (!currentIndexMap.has(idx.name)) {
            alterSchema.addIndexes.push(idx);
          }
        });
        
        // 查找删除的索引
        (currentStructure.indexes || []).forEach(idx => {
          if (!newIndexMap.has(idx.name)) {
            alterSchema.dropIndexes.push(idx.name);
          }
        });
        
        // 比较外键
        const currentFKMap = new Map();
        (currentStructure.foreignKeys || []).forEach(fk => {
          currentFKMap.set(fk.name, fk);
        });
        
        const newFKMap = new Map();
        (newStructure.foreignKeys || []).forEach(fk => {
          newFKMap.set(fk.name, fk);
        });
        
        // 查找新增的外键
        (newStructure.foreignKeys || []).forEach(fk => {
          if (!currentFKMap.has(fk.name)) {
            alterSchema.addForeignKeys.push(fk);
          }
        });
        
        // 查找删除的外键
        (currentStructure.foreignKeys || []).forEach(fk => {
          if (!newFKMap.has(fk.name)) {
            alterSchema.dropForeignKeys.push(fk.name);
          }
        });
      }
      
      // 表级选项
      if (newStructure.engine || newStructure.charset || newStructure.collation || newStructure.comment) {
        alterSchema.engine = newStructure.engine;
        alterSchema.charset = newStructure.charset;
        alterSchema.collation = newStructure.collation;
        alterSchema.comment = newStructure.comment;
      }
      
      return alterSchema;
    },
    
    // 规范化列结构，确保数值字段为数字类型
    normalizeColumnSchema(column) {
      const normalized = { ...column };
      
      // 确保length是数字类型
      if (normalized.length !== undefined && normalized.length !== null) {
        const numLength = parseInt(normalized.length);
        if (!isNaN(numLength)) {
          normalized.length = numLength;
        } else if (typeof normalized.length === 'string' && normalized.length.includes(',')) {
          // 对于enum/set类型，保留字符串格式的枚举值
        } else {
          // 如果不是数字或枚举值，则设为undefined
          normalized.length = undefined;
        }
      }
      
      // 确保precision是数字类型
      if (normalized.precision !== undefined && normalized.precision !== null) {
        const numPrecision = parseInt(normalized.precision);
        if (!isNaN(numPrecision)) {
          normalized.precision = numPrecision;
        } else {
          normalized.precision = undefined;
        }
      }
      
      // 确保scale是数字类型
      if (normalized.scale !== undefined && normalized.scale !== null) {
        const numScale = parseInt(normalized.scale);
        if (!isNaN(numScale)) {
          normalized.scale = numScale;
        } else {
          normalized.scale = undefined;
        }
      }
      
      return normalized;
    },
    
    // 检查列是否有变化
    isColumnChanged(newCol, oldCol) {
      if (!oldCol) return true;
      
      // 比较主要属性
      if (newCol.type.toUpperCase() !== oldCol.type.toUpperCase()) return true;
      if (String(newCol.length || '') !== String(oldCol.length || '')) return true;
      if (String(newCol.precision || '') !== String(oldCol.precision || '')) return true;
      if (String(newCol.scale || '') !== String(oldCol.scale || '')) return true;
      if (Boolean(newCol.notNull) !== Boolean(oldCol.notNull)) return true;
      if (Boolean(newCol.autoIncrement) !== Boolean(oldCol.autoIncrement)) return true;
      if (Boolean(newCol.primaryKey) !== Boolean(oldCol.primaryKey)) return true;
      
      // 比较默认值
      const newDefault = newCol.defaultValue || '';
      const oldDefault = oldCol.defaultValue || '';
      if (newDefault !== oldDefault) return true;
      
      // 比较注释
      const newComment = newCol.comment || '';
      const oldComment = oldCol.comment || '';
      if (newComment !== oldComment) return true;
      
      return false;
    },
    
    // 检查是否有任何修改
    hasChanges(alterSchema) {
      return alterSchema.addColumns.length > 0 ||
             alterSchema.modifyColumns.length > 0 ||
             alterSchema.dropColumns.length > 0 ||
             Object.keys(alterSchema.renameColumns).length > 0 ||
             alterSchema.addIndexes.length > 0 ||
             alterSchema.dropIndexes.length > 0 ||
             alterSchema.addForeignKeys.length > 0 ||
             alterSchema.dropForeignKeys.length > 0 ||
             alterSchema.engine ||
             alterSchema.charset ||
             alterSchema.collation ||
             alterSchema.comment;
    },
    
    // 生成创建表SQL
    generateCreateSQL(structure) {
      const databaseType = structure.databaseType || 'mysql';
      
      // 使用策略模式，根据数据库类型选择不同的SQL生成策略
      const sqlGenerators = {
        mysql: this.generateMySQLCreateSQL,
        postgresql: this.generateMySQLCreateSQL, // 暂时复用MySQL的
        sqlite: this.generateMySQLCreateSQL, // 暂时复用MySQL的
        sqlserver: this.generateMySQLCreateSQL, // 暂时复用MySQL的
        oracle: this.generateMySQLCreateSQL, // 暂时复用MySQL的
        dameng: this.generateDaMengCreateSQL // 达梦特定实现
      };
      
      // 获取对应的生成器函数，如果不存在则使用MySQL作为默认值
      const generator = sqlGenerators[databaseType] || sqlGenerators.mysql;
      
      // 调用生成器函数并返回结果
      return generator.call(this, structure);
    },
    
    // MySQL创建表SQL生成
    generateMySQLCreateSQL(structure) {
      // 确保使用完整表名（包含数据库名）
      const database = structure.database ? `\`${structure.database}\`.` : '';
      
      // MySQL示例
      let sql = `CREATE TABLE ${database}\`${structure.name}\` (\n`;
      
      // 添加列定义
      const columnDefs = structure.columns.map(col => {
        let def = `  \`${col.name}\` ${col.type.toUpperCase()}`;
        
        // 长度/值
        if (col.length) {
          def += `(${col.length})`;
        }
        
        // 非空约束
        if (col.notNull) {
          def += ' NOT NULL';
        }
        
        // 自增
        if (col.autoIncrement) {
          def += ' AUTO_INCREMENT';
        }
        
        // 默认值
        if (col.defaultValue) {
          def += ` DEFAULT '${col.defaultValue}'`;
        }
        
        return def;
      });
      
      sql += columnDefs.join(',\n');
      
      // 添加主键
      const primaryKey = structure.columns.find(col => col.primaryKey);
      if (primaryKey) {
        sql += `,\n  PRIMARY KEY (\`${primaryKey.name}\`)`;
      }
      
      sql += '\n)';
      
      // 表选项
      if (structure.engine) {
        sql += ` ENGINE=${structure.engine}`;
      }
      
      if (structure.charset) {
        sql += ` DEFAULT CHARSET=${structure.charset}`;
      }
      
      if (structure.comment) {
        sql += ` COMMENT='${structure.comment}'`;
      }
      
      sql += ';';
      return sql;
    },
    
    // 达梦数据库创建表SQL生成
    generateDaMengCreateSQL(structure) {
      // 确保使用完整表名（包含数据库名）
      const database = structure.database ? `"${structure.database}".` : ''
      const fullTableName = `${database}"${structure.name}"`
      
      let sql = `CREATE TABLE ${fullTableName}\n(\n`
      
      // 列定义
      const columnDefs = []
      const primaryKeyColumns = []
      
      structure.columns.forEach(col => {
        let colDef = `"${col.name}" ${col.type.toUpperCase()}`
        
        // 处理长度、精度
        if (col.length && ['VARCHAR', 'CHAR', 'VARCHAR2'].includes(col.type.toUpperCase())) {
          colDef += `(${col.length})`
        } else if (col.precision && ['DECIMAL', 'NUMBER', 'NUMERIC'].includes(col.type.toUpperCase())) {
          colDef += `(${col.precision}${col.scale ? `,${col.scale}` : ''})`
        }
        
        // 处理自增（达梦使用AUTO_INCREMENT）
        if (col.autoIncrement) {
          colDef += ' AUTO_INCREMENT'
        }
        
        // 处理NOT NULL
        if (col.notNull) {
          colDef += ' NOT NULL'
        }
        
        // 处理默认值
        if (col.defaultValue) {
          colDef += ` DEFAULT ${col.defaultValue}`
        }
        
        columnDefs.push(colDef)
        
        // 收集主键列
        if (col.primaryKey) {
          primaryKeyColumns.push(`"${col.name}"`)
        }
      })
      
      sql += columnDefs.join(',\n')
      
      // 添加主键约束（达梦使用CLUSTER PRIMARY KEY）
      if (primaryKeyColumns.length > 0) {
        sql += `,\nCLUSTER PRIMARY KEY(${primaryKeyColumns.join(', ')})`
      }
      
      // 结束列定义
      sql += '\n)'
      
      // 添加存储参数（修复语法）
      // 达梦数据库的正确STORAGE语法
      if (structure.tablespace) {
        sql += `\nSTORAGE(ON "${structure.tablespace}")`
      }
      
      // 如果有自增列，设置起始值
      const autoIncrementCol = structure.columns.find(col => col.autoIncrement)
      if (autoIncrementCol && structure.autoIncrementValue) {
        sql += `\nAUTO_INCREMENT = ${structure.autoIncrementValue}`
      }
      
      sql += ';'
      
      // 处理列注释（达梦使用COMMENT ON COLUMN语法）
      const commentStatements = structure.columns.map(col => {
        if (col.comment) {
          // 确保注释中的单引号被正确转义
          return `COMMENT ON COLUMN ${fullTableName}."${col.name}" IS '${col.comment.replace(/'/g, "''")}';\n`;
        }
        return null;
      }).filter(Boolean);
      
      if (commentStatements.length > 0) {
        sql += '\n' + commentStatements.join('');
      }
      
      // 处理表注释
      if (structure.comment) {
        // 确保注释中的单引号被正确转义
        sql += `\nCOMMENT ON TABLE ${fullTableName} IS '${structure.comment.replace(/'/g, "''")}';`;
      }
      
      return sql
    },
    
    // 修改表SQL生成函数
    generateAlterSQL(structure, originalStructure = null) {
      const databaseType = structure.databaseType || 'mysql';
      
      // 使用策略模式，根据数据库类型选择不同的SQL生成策略
      const sqlGenerators = {
        mysql: this.generateMySQLAlterSQL,
        postgresql: this.generatePostgreSQLAlterSQL,
        sqlite: this.generateSQLiteAlterSQL,
        sqlserver: this.generateSQLServerAlterSQL,
        oracle: this.generateOracleAlterSQL,
        dameng: this.generateDaMengAlterSQL
      };
      
      // 获取对应的生成器函数，如果不存在则使用MySQL作为默认值
      const generator = sqlGenerators[databaseType] || sqlGenerators.mysql;
      
      // 调用生成器函数并返回结果
      return generator.call(this, structure, originalStructure);
    },
    
    // MySQL的ALTER TABLE语句生成
    generateMySQLAlterSQL(structure, originalStructure = null) {
      // 拆分为多个SQL语句，而不是一个大的ALTER TABLE
      const sqlStatements = [];
      
      // 确保使用完整表名（包含数据库名）
      const database = structure.database ? `\`${structure.database}\`.` : '';
      const fullTableName = `${database}\`${structure.name}\``;
      
      // 判断列是否变更的函数
      const isColumnChanged = (newCol, oldCol) => {
        if (!oldCol) return true; // 新增列
        
        // 比较列的主要属性
        if (newCol.type.toUpperCase() !== oldCol.type.toUpperCase()) return true;
        
        // 对于需要长度的类型，比较长度
        if (this.needsLengthForMySQL(newCol.type.toUpperCase())) {
          if (String(newCol.length || '') !== String(oldCol.length || '')) return true;
        }
        
        // 比较其他重要属性 - 确保进行严格的布尔值比较
        if (Boolean(newCol.notNull) !== Boolean(oldCol.notNull)) return true;
        if (Boolean(newCol.autoIncrement) !== Boolean(oldCol.autoIncrement)) return true;
        if (Boolean(newCol.primaryKey) !== Boolean(oldCol.primaryKey)) return true;
        
        // 比较默认值 - 注意处理null和空字符串
        const newDefault = newCol.defaultValue || '';
        const oldDefault = oldCol.defaultValue || '';
        if (newDefault !== oldDefault) return true;
        
        // 比较注释
        const newComment = newCol.comment || '';
        const oldComment = oldCol.comment || '';
        if (newComment !== oldComment) return true;
        
        return false; // 如果以上都相同，则认为列没有变更
      };
      
      // 1. 处理列修改 - 只修改变更的列
      const changedColumns = [];
      
      if (structure.columns && structure.columns.length > 0) {
        if (originalStructure && originalStructure.columns) {
          // 只有在有原始结构的情况下才进行比较
          const originalColumnsMap = new Map();
          originalStructure.columns.forEach(col => {
            originalColumnsMap.set(col.name, col);
          });
          
          // 筛选出变更的列
          structure.columns.forEach(newCol => {
            const oldCol = originalColumnsMap.get(newCol.name);
            if (isColumnChanged(newCol, oldCol)) {
              changedColumns.push(newCol);
            }
          });
          
          console.log(`Found ${changedColumns.length} changed columns out of ${structure.columns.length} total columns`);
        } else {
          // 如果没有原始结构，默认所有列都需要修改
          changedColumns.push(...structure.columns);
        }
      }
      
      // 分别生成每列的ALTER语句，而不是合并到一个大语句中
      changedColumns.forEach(col => {
        const upperType = col.type.toUpperCase();
        let columnSql = `ALTER TABLE ${fullTableName}\n  MODIFY COLUMN \`${col.name}\` ${upperType}`;
        
        // 长度/值 - 只对需要长度的类型添加长度参数
        if (col.length && this.needsLengthForMySQL(upperType)) {
          // 对于ENUM和SET类型，处理values而不是length
          if (['ENUM', 'SET'].includes(upperType)) {
            if (col.values && Array.isArray(col.values) && col.values.length > 0) {
              columnSql += `(${col.values.map(v => `'${v}'`).join(',')})`;
            } else if (typeof col.length === 'string' && col.length.includes(',')) {
              // 兼容length字段存储的逗号分隔值的情况
              const values = col.length.split(',').map(v => `'${v.trim()}'`).join(',');
              columnSql += `(${values})`;
            }
          } else {
            columnSql += `(${col.length})`;
          }
        }
        
        // 非空约束
        if (col.notNull) {
          columnSql += ' NOT NULL';
        } else {
          columnSql += ' NULL';
        }
        
        // 自增
        if (col.autoIncrement) {
          columnSql += ' AUTO_INCREMENT';
        }
        
        // 默认值
        if (col.defaultValue !== undefined && col.defaultValue !== null) {
          if (col.defaultValue.toUpperCase() === 'NULL') {
            columnSql += ` DEFAULT NULL`;
          } else if (['CURRENT_TIMESTAMP', 'NOW()'].includes(col.defaultValue.toUpperCase())) {
            columnSql += ` DEFAULT ${col.defaultValue}`;
          } else {
            // 根据类型判断是否需要引号
            if (this.needsQuotesForDefaultValue(upperType)) {
              columnSql += ` DEFAULT '${col.defaultValue}'`;
            } else {
              columnSql += ` DEFAULT ${col.defaultValue}`;
            }
          }
        }
        
        // 注释
        if (col.comment) {
          columnSql += ` COMMENT '${col.comment.replace(/'/g, "''")}'`;
        }
        
        sqlStatements.push(`${columnSql};`);
      });
      
      // 2. 检查表选项是否变更
      let tableOptionsChanged = false;
      
      if (originalStructure) {
        if (structure.engine !== originalStructure.engine) tableOptionsChanged = true;
        if (structure.charset !== originalStructure.charset) tableOptionsChanged = true;
        if (structure.collation !== originalStructure.collation) tableOptionsChanged = true;
        if (structure.comment !== originalStructure.comment) tableOptionsChanged = true;
      } else {
        // 如果没有原始结构，默认表选项都需要修改
        tableOptionsChanged = true;
      }
      
      // 3. 然后添加表选项修改语句（使用单独的ALTER TABLE语句）
      if (tableOptionsChanged) {
        if (structure.engine) {
          sqlStatements.push(`ALTER TABLE ${fullTableName} ENGINE = ${structure.engine};`);
        }
        
        if (structure.charset) {
          sqlStatements.push(`ALTER TABLE ${fullTableName} DEFAULT CHARSET = ${structure.charset};`);
        }
        
        if (structure.collation) {
          sqlStatements.push(`ALTER TABLE ${fullTableName} COLLATE = ${structure.collation};`);
        }
        
        if (structure.comment) {
          sqlStatements.push(`ALTER TABLE ${fullTableName} COMMENT = '${structure.comment.replace(/'/g, "''")}';`);
        }
      }
      
      return sqlStatements.join('\n');
    },
    
    // 判断MySQL数据类型是否需要长度参数
    needsLengthForMySQL(type) {
      // 需要长度参数的类型列表
      const typesNeedLength = [
        // 字符串类型
        'CHAR', 'VARCHAR', 
        
        // 二进制类型
        'BINARY', 'VARBINARY',
        
        // 数值类型中可选长度的
        'BIT', 'TINYINT', 'SMALLINT', 'MEDIUMINT', 'INT', 'INTEGER',
        
        // 精确小数类型 - 必须指定精度和小数位
        'DECIMAL', 'NUMERIC',
        
        // 浮点类型 - 可选长度
        'FLOAT', 'DOUBLE',
        
        // 枚举类型
        'ENUM', 'SET'
      ];
      
      return typesNeedLength.includes(type);
    },
    
    // 判断默认值是否需要引号
    needsQuotesForDefaultValue(type) {
      // 不需要引号的类型（数值、布尔等）
      const typesNoQuotes = [
        'TINYINT', 'SMALLINT', 'MEDIUMINT', 'INT', 'INTEGER', 'BIGINT',
        'FLOAT', 'DOUBLE', 'DECIMAL', 'NUMERIC', 'BIT', 'BOOL', 'BOOLEAN'
      ];
      
      return !typesNoQuotes.includes(type);
    },
    
    // PostgreSQL的ALTER TABLE语句生成
    generatePostgreSQLAlterSQL(structure) {
      // PostgreSQL使用双引号作为标识符
      // 确保使用完整表名（包含schema名）
      const schema = structure.database ? `"${structure.database}".` : '';
      let sql = `ALTER TABLE ${schema}"${structure.name}"`;
      
      // PostgreSQL需要分别修改列的类型和约束
      if (structure.columns && structure.columns.length > 0) {
        const columnAlters = [];
        
        structure.columns.forEach(col => {
          // 类型修改
          let typeSql = `\n  ALTER COLUMN "${col.name}" TYPE ${col.type.toUpperCase()}`;
          if (col.length) {
            typeSql += `(${col.length})`;
          }
          columnAlters.push(typeSql);
          
          // 非空约束
          if (col.notNull) {
            columnAlters.push(`\n  ALTER COLUMN "${col.name}" SET NOT NULL`);
          } else {
            columnAlters.push(`\n  ALTER COLUMN "${col.name}" DROP NOT NULL`);
          }
          
          // 默认值
          if (col.defaultValue) {
            if (col.defaultValue.toUpperCase() === 'NULL') {
              columnAlters.push(`\n  ALTER COLUMN "${col.name}" DROP DEFAULT`);
            } else if (['CURRENT_TIMESTAMP', 'NOW()'].includes(col.defaultValue.toUpperCase())) {
              columnAlters.push(`\n  ALTER COLUMN "${col.name}" SET DEFAULT ${col.defaultValue}`);
            } else {
              columnAlters.push(`\n  ALTER COLUMN "${col.name}" SET DEFAULT '${col.defaultValue}'`);
            }
          } else {
            columnAlters.push(`\n  ALTER COLUMN "${col.name}" DROP DEFAULT`);
          }
          
          // 注释
          if (col.comment) {
            columnAlters.push(`\n  COMMENT ON COLUMN "${structure.name}"."${col.name}" IS '${col.comment}'`);
          }
        });
        
        sql += columnAlters.join(',');
      }
      
      sql += ';';
      return sql;
    },
    
    // SQLite的ALTER TABLE语句生成
    generateSQLiteAlterSQL(structure) {
      // SQLite的ALTER TABLE功能有限，通常需要使用CREATE TABLE AS + INSERT + DROP TABLE的方法
      // 这里提供一个简化的实现，仅支持基本的列修改
      let sql = `-- 警告: SQLite对ALTER TABLE支持有限\n`;
      sql += `-- 以下是基本修改操作，复杂修改可能需要重建表\n\n`;
      
      // SQLite通常不使用数据库限定符，因为每个数据库文件就是一个数据库
      
      // 添加列修改语句 - SQLite只支持添加列，不支持修改列
      if (structure.columns && structure.columns.length > 0) {
        const addColumnStatements = structure.columns
          .filter(col => col.isNew) // 假设有一个isNew标记表示这是新列
          .map(col => {
            let columnSql = `ALTER TABLE "${structure.name}" ADD COLUMN "${col.name}" ${col.type.toUpperCase()}`;
            
            // 长度/值 - SQLite通常忽略这个
            if (col.length && ['VARCHAR', 'CHAR'].includes(col.type.toUpperCase())) {
              columnSql += `(${col.length})`;
            }
            
            // 约束
            if (col.notNull) {
              columnSql += ' NOT NULL';
            }
            
            // 默认值
            if (col.defaultValue) {
              if (col.defaultValue.toUpperCase() === 'NULL') {
                // SQLite不支持DEFAULT NULL和NOT NULL组合
                if (!col.notNull) {
                  columnSql += ` DEFAULT NULL`;
                }
              } else if (['CURRENT_TIMESTAMP', 'NOW()'].includes(col.defaultValue.toUpperCase())) {
                columnSql += ` DEFAULT ${col.defaultValue}`;
              } else {
                columnSql += ` DEFAULT '${col.defaultValue}'`;
              }
            }
            
            return columnSql + ';';
          });
        
        if (addColumnStatements.length > 0) {
          sql += addColumnStatements.join('\n');
        } else {
          sql += `-- 注意: SQLite不支持修改现有列，需要重建表\n`;
          sql += `-- 建议使用以下模式:\n`;
          sql += `-- 1. 创建新表结构\n`;
          sql += `-- 2. 复制数据\n`;
          sql += `-- 3. 删除旧表\n`;
          sql += `-- 4. 重命名新表\n\n`;
          
          // 提供重建表的示例SQL
          sql += `/* 示例: 重建表的完整SQL:
BEGIN TRANSACTION;

-- 创建新表
CREATE TABLE "${structure.name}_new" (
  -- 在这里定义新的表结构
);

-- 复制数据
INSERT INTO "${structure.name}_new" SELECT * FROM "${structure.name}";

-- 删除旧表
DROP TABLE "${structure.name}";

-- 重命名新表
ALTER TABLE "${structure.name}_new" RENAME TO "${structure.name}";

COMMIT;
*/`;
        }
      }
      
      return sql;
    },
    
    // SQL Server的ALTER TABLE语句生成
    generateSQLServerAlterSQL(structure) {
      // SQL Server使用方括号作为标识符
      // 确保使用完整表名（包含schema名）
      const schema = structure.database ? `[${structure.database}].` : '';
      let sql = `ALTER TABLE ${schema}[${structure.name}]`;
      
      // 添加列修改语句
      if (structure.columns && structure.columns.length > 0) {
        const columnAlters = structure.columns.map(col => {
          let columnSql = `\n  ALTER COLUMN [${col.name}] ${col.type.toUpperCase()}`;
          
          // 长度/值
          if (col.length) {
            // 处理特殊类型
            if (['NVARCHAR', 'VARCHAR', 'CHAR', 'NCHAR'].includes(col.type.toUpperCase())) {
              if (col.length.toUpperCase() === 'MAX') {
                columnSql += `(MAX)`;
              } else {
                columnSql += `(${col.length})`;
              }
            } else if (['DECIMAL', 'NUMERIC'].includes(col.type.toUpperCase())) {
              columnSql += `(${col.length})`;
            }
          }
          
          // 非空约束
          if (col.notNull) {
            columnSql += ' NOT NULL';
          } else {
            columnSql += ' NULL';
          }
          
          return columnSql;
        });
        
        sql += columnAlters.join(',');
      }
      
      // 默认值约束 - SQL Server需要单独的语句
      const defaultConstraints = [];
      structure.columns.forEach((col, index) => {
        if (col.defaultValue) {
          const constraintName = `DF_${structure.name}_${col.name}`;
          let defaultValue = col.defaultValue;
          
          if (col.defaultValue.toUpperCase() !== 'NULL') {
            if (!['CURRENT_TIMESTAMP', 'GETDATE()'].includes(col.defaultValue.toUpperCase())) {
              defaultValue = `'${col.defaultValue}'`;
            }
            
            defaultConstraints.push(
              `\nALTER TABLE ${schema}[${structure.name}] ADD CONSTRAINT [${constraintName}] DEFAULT ${defaultValue} FOR [${col.name}];`
            );
          }
        }
      });
      
      sql += ';';
      
      // 添加默认值约束语句
      if (defaultConstraints.length > 0) {
        sql += defaultConstraints.join('');
      }
      
      return sql;
    },
    
    // Oracle的ALTER TABLE语句生成
    generateOracleAlterSQL(structure) {
      // Oracle使用双引号作为标识符
      // 确保使用完整表名（包含schema名）
      const schema = structure.database ? `"${structure.database}".` : '';
      let sql = `ALTER TABLE ${schema}"${structure.name}"`;
      
      // 添加列修改语句
      if (structure.columns && structure.columns.length > 0) {
        const columnAlters = [];
        
        structure.columns.forEach(col => {
          // Oracle中修改列类型使用MODIFY关键字
          let modifySql = `\n  MODIFY "${col.name}" ${col.type.toUpperCase()}`;
          
          // 长度/值
          if (col.length) {
            if (['VARCHAR2', 'CHAR', 'NVARCHAR2', 'NCHAR'].includes(col.type.toUpperCase())) {
              modifySql += `(${col.length})`;
            } else if (['NUMBER'].includes(col.type.toUpperCase())) {
              modifySql += `(${col.length})`;
            }
          }
          
          // 非空约束
          if (col.notNull) {
            modifySql += ' NOT NULL';
          } else {
            modifySql += ' NULL';
          }
          
          // 默认值
          if (col.defaultValue) {
            if (col.defaultValue.toUpperCase() === 'NULL') {
              modifySql += ` DEFAULT NULL`;
            } else if (['CURRENT_TIMESTAMP', 'SYSDATE', 'SYSTIMESTAMP'].includes(col.defaultValue.toUpperCase())) {
              modifySql += ` DEFAULT ${col.defaultValue}`;
            } else {
              modifySql += ` DEFAULT '${col.defaultValue}'`;
            }
          }
          
          columnAlters.push(modifySql);
          
          // 注释 - Oracle使用单独的COMMENT语句
          if (col.comment) {
            columnAlters.push(`\n  -- 需要在主ALTER TABLE语句之后执行：`);
            columnAlters.push(`\n  -- COMMENT ON COLUMN "${structure.name}"."${col.name}" IS '${col.comment}'`);
          }
        });
        
        sql += columnAlters.join(',');
      }
      
      sql += ';';
      
      // 添加列注释语句
      const commentStatements = structure.columns
        .filter(col => col.comment)
        .map(col => {
          return `COMMENT ON COLUMN ${schema}"${structure.name}"."${col.name}" IS '${col.comment}';`;
        });
      
      if (commentStatements.length > 0) {
        sql += '\n\n-- 列注释语句：\n' + commentStatements.join('\n');
      }
      
      // 表空间和存储参数设置 (Oracle特有)
      if (structure.tablespace) {
        sql += `\n\n-- 表空间设置：\nALTER TABLE ${schema}"${structure.name}" MOVE TABLESPACE ${structure.tablespace};`;
      }
      
      return sql;
    },
    
    // 达梦数据库的ALTER TABLE语句生成
    generateDaMengAlterSQL(structure, originalStructure = null) {
      let sql = '';
      
      // 确保使用完整表名
      const database = structure.database ? `"${structure.database}".` : '';
      const fullTableName = `${database}"${structure.name}"`;
      
      // 判断列是否变更的函数
      const isColumnChanged = (newCol, oldCol) => {
        if (!oldCol) return true; // 新增列
        
        // 比较列的主要属性
        if (newCol.type.toUpperCase() !== oldCol.type.toUpperCase()) return true;
        
        // 对于需要长度的类型，比较长度
        if (this.needsLengthForDaMeng(newCol.type.toUpperCase())) {
          if (String(newCol.length || '') !== String(oldCol.length || '')) return true;
        }
        
        // 对于需要精度的类型，比较精度和小数位
        if (this.needsPrecisionForDaMeng(newCol.type.toUpperCase())) {
          if (String(newCol.precision || '') !== String(oldCol.precision || '')) return true;
          if (String(newCol.scale || '') !== String(oldCol.scale || '')) return true;
        }
        
        // 比较其他重要属性
        if (Boolean(newCol.notNull) !== Boolean(oldCol.notNull)) return true;
        if (Boolean(newCol.autoIncrement) !== Boolean(oldCol.autoIncrement)) return true;
        if (Boolean(newCol.primaryKey) !== Boolean(oldCol.primaryKey)) return true;
        
        // 比较默认值
        const newDefault = newCol.defaultValue || '';
        const oldDefault = oldCol.defaultValue || '';
        if (newDefault !== oldDefault) return true;
        
        // 比较注释
        const newComment = newCol.comment || '';
        const oldComment = oldCol.comment || '';
        if (newComment !== oldComment) return true;
        
        return false; // 如果以上都相同，则认为列没有变更
      };
      
      // 获取变更的列
      const changedColumns = [];
      
      if (structure.columns && structure.columns.length > 0) {
        if (originalStructure && originalStructure.columns) {
          // 只有在有原始结构的情况下才进行比较
          const originalColumnsMap = new Map();
          originalStructure.columns.forEach(col => {
            originalColumnsMap.set(col.name, col);
          });
          
          // 筛选出变更的列
          structure.columns.forEach(newCol => {
            const oldCol = originalColumnsMap.get(newCol.name);
            if (isColumnChanged(newCol, oldCol)) {
              changedColumns.push(newCol);
            }
          });
          
          console.log(`Found ${changedColumns.length} changed columns out of ${structure.columns.length} total columns`);
        } else {
          // 如果没有原始结构，默认所有列都需要修改
          changedColumns.push(...structure.columns);
        }
      }
      
      // 获取已删除的列
      const deletedColumns = [];
      if (originalStructure && originalStructure.columns) {
        const newColumnsMap = new Map();
        structure.columns.forEach(col => {
          newColumnsMap.set(col.name, col);
        });
        
        // 筛选出已删除的列
        originalStructure.columns.forEach(oldCol => {
          if (!newColumnsMap.has(oldCol.name)) {
            deletedColumns.push(oldCol);
          }
        });
      }
      
      // 获取新增的列
      const addedColumns = [];
      if (originalStructure && originalStructure.columns) {
        const originalColumnsMap = new Map();
        originalStructure.columns.forEach(col => {
          originalColumnsMap.set(col.name, col);
        });
        
        // 筛选出新增的列
        structure.columns.forEach(newCol => {
          if (!originalColumnsMap.has(newCol.name)) {
            addedColumns.push(newCol);
          }
        });
      }
      
      // 生成ALTER TABLE语句
      if (changedColumns.length > 0 || deletedColumns.length > 0 || addedColumns.length > 0) {
        // 处理已修改的列
        const modifyStatements = changedColumns.filter(col => 
          !addedColumns.some(added => added.name === col.name) // 过滤掉新增的列，因为会在下面单独处理
        ).map(col => {
          const upperType = col.type.toUpperCase();
          let columnSql = `ALTER TABLE ${fullTableName} MODIFY "${col.name}" ${upperType}`;
          
          // 长度参数
          if (col.length && this.needsLengthForDaMeng(upperType)) {
            columnSql += `(${col.length})`;
          } else if (this.needsPrecisionForDaMeng(upperType)) {
            if (col.precision) {
              if (col.scale) {
                columnSql += `(${col.precision},${col.scale})`;
              } else {
                columnSql += `(${col.precision})`;
              }
            }
          }
          
          // 非空约束
          if (col.notNull) {
            columnSql += ' NOT NULL';
          } else {
            columnSql += ' NULL';
          }
          
          // 达梦数据库不支持在MODIFY语句中添加自增标识，需要使用单独的语句
          
          // 默认值
          if (col.defaultValue) {
            if (['CURRENT_TIMESTAMP', 'SYSDATE', 'SYSTIMESTAMP', 'NULL'].includes(col.defaultValue.toUpperCase())) {
              columnSql += ` DEFAULT ${col.defaultValue.toUpperCase()}`;
            } else {
              columnSql += ` DEFAULT '${col.defaultValue}'`;
            }
          }
          
          return columnSql + ';';
        });
        
        // 处理已删除的列
        const dropStatements = deletedColumns.map(col => 
          `ALTER TABLE ${fullTableName} DROP COLUMN "${col.name}";`
        );
        
        // 处理新增的列
        const addStatements = addedColumns.map(col => {
          const upperType = col.type.toUpperCase();
          let columnSql = `ALTER TABLE ${fullTableName} ADD "${col.name}" ${upperType}`;
          
          // 长度参数
          if (col.length && this.needsLengthForDaMeng(upperType)) {
            columnSql += `(${col.length})`;
          } else if (this.needsPrecisionForDaMeng(upperType)) {
            if (col.precision) {
              if (col.scale) {
                columnSql += `(${col.precision},${col.scale})`;
              } else {
                columnSql += `(${col.precision})`;
              }
            }
          }
          
          // 非空约束
          if (col.notNull) {
            columnSql += ' NOT NULL';
          }
          
          // 自增标识（达梦使用IDENTITY）
          if (col.autoIncrement) {
            columnSql += ' IDENTITY';
          }
          
          // 默认值
          if (col.defaultValue) {
            if (['CURRENT_TIMESTAMP', 'SYSDATE', 'SYSTIMESTAMP', 'NULL'].includes(col.defaultValue.toUpperCase())) {
              columnSql += ` DEFAULT ${col.defaultValue.toUpperCase()}`;
            } else {
              columnSql += ` DEFAULT '${col.defaultValue}'`;
            }
          }
          
          return columnSql + ';';
        });
        
        // 合并所有语句
        sql = [...dropStatements, ...addStatements, ...modifyStatements].join('\n');
        
        // 处理列注释（达梦使用COMMENT ON COLUMN语法）
        const commentStatements = structure.columns.map(col => {
          if (col.comment) {
            // 修复达梦数据库注释语法：引号需要正确处理，注释内容使用单引号
            return `COMMENT ON COLUMN ${fullTableName}."${col.name}" IS '${col.comment.replace(/'/g, "''")}';`;
          }
          return null;
        }).filter(Boolean);
        
        if (commentStatements.length > 0) {
          sql += '\n' + commentStatements.join('\n');
        }
        
        // 处理表注释
        if (structure.comment) {
          // 修复达梦数据库表注释语法：确保注释内容使用单引号，并转义内部的单引号
          sql += `\nCOMMENT ON TABLE ${fullTableName} IS '${structure.comment.replace(/'/g, "''")}';`;
        }
      }
      
      return sql;
    },
    
    // 判断达梦数据库的列类型是否需要长度参数
    needsLengthForDaMeng(type) {
      return ['VARCHAR', 'VARCHAR2', 'CHAR', 'BINARY', 'VARBINARY'].includes(type.toUpperCase());
    },
    
    // 判断达梦数据库的列类型是否需要精度参数
    needsPrecisionForDaMeng(type) {
      return ['NUMBER', 'DECIMAL', 'NUMERIC', 'FLOAT'].includes(type.toUpperCase());
    },
    
    // 清除所有相关的表结构缓存
    clearAllTableStructureCaches(configId, database) {
      console.log(`Clearing all table structure caches for ${configId}:${database}`)
      
      // 清除指定数据库的所有表缓存
      const prefix = `${configId}:${database}:`;
      let clearedCount = 0;
      
      for (const key of this.structureCache.keys()) {
        if (key.startsWith(prefix)) {
          this.structureCache.delete(key);
          clearedCount++;
        }
      }
      
      console.log(`Cleared ${clearedCount} table structure cache entries`)
    },
    
    // 清除表结构缓存
    clearStructureCache(configId, database, table) {
      if (configId && database && table) {
        const key = `${configId}:${database}:${table}`;
        this.structureCache.delete(key);
      } else if (configId && database) {
        // 清除指定数据库的所有表缓存
        const prefix = `${configId}:${database}:`;
        for (const key of this.structureCache.keys()) {
          if (key.startsWith(prefix)) {
            this.structureCache.delete(key);
          }
        }
      } else if (configId) {
        // 清除指定连接的所有缓存
        const prefix = `${configId}:`;
        for (const key of this.structureCache.keys()) {
          if (key.startsWith(prefix)) {
            this.structureCache.delete(key);
          }
        }
      } else {
        // 清除所有缓存
        this.structureCache.clear();
      }
    },
    
    // 重置状态
    resetState() {
      this.structure = null;
      this.isLoading = false;
      this.error = null;
    }
  }
}) 